using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("LoadingScreen")]
	public class LoadingScreen : MonoBehaviour
	{
		public enum Phase
		{
			INVALID,
			WAITING_FOR_SCENE_UNLOAD,
			WAITING_FOR_SCENE_LOAD,
			WAITING_FOR_BLOCKERS,
			FADING_OUT,
			FADING_IN
		}

		[Attribute38("LoadingScreen.TransitionParams")]
		public class TransitionParams : MonoClass
		{
			public bool m_enabled => method_2<bool>("m_enabled");

			public List<GameObject> m_objects => method_3<Class271<GameObject>>("m_objects")?.method_25();

			public List<Camera> m_cameras => method_3<Class271<Camera>>("m_cameras")?.method_25();

			public Camera m_freezeFrameCamera => method_3<Camera>("m_freezeFrameCamera");

			public int m_blockerCount => method_2<int>("m_blockerCount");

			public bool m_fadeOut => method_2<bool>("m_fadeOut");

			public bool m_fadeIn => method_2<bool>("m_fadeIn");

			public Color m_fadeColor => method_2<Color>("m_fadeColor");

			public bool m_clearPreviousAssets => method_2<bool>("m_clearPreviousAssets");

			public bool ClearPreviousAssets => method_11<bool>("get_ClearPreviousAssets", Array.Empty<object>());

			public TransitionParams(IntPtr address, string className)
				: base(address, className)
			{
			}

			public TransitionParams(IntPtr address)
				: this(address, "TransitionParams")
			{
			}

			public bool IsEnabled()
			{
				return method_11<bool>("IsEnabled", Array.Empty<object>());
			}

			public void Enable(bool enable)
			{
				method_8("Enable", enable);
			}

			public void AddObject(Component c)
			{
				method_9("AddObject", new Class276.Enum20[1] { Class276.Enum20.Class }, c);
			}

			public void AddObject(GameObject go)
			{
				method_9("AddObject", new Class276.Enum20[1] { Class276.Enum20.Class }, go);
			}

			public void AddBlocker()
			{
				method_9("AddBlocker", new Class276.Enum20[0]);
			}

			public void AddBlocker(int count)
			{
				method_9("AddBlocker", new Class276.Enum20[1] { Class276.Enum20.I4 }, count);
			}

			public void RemoveBlocker()
			{
				method_9("RemoveBlocker", new Class276.Enum20[0]);
			}

			public void RemoveBlocker(int count)
			{
				method_9("RemoveBlocker", new Class276.Enum20[1] { Class276.Enum20.I4 }, count);
			}

			public int GetBlockerCount()
			{
				return method_11<int>("GetBlockerCount", Array.Empty<object>());
			}

			public void SetFreezeFrameCamera(Camera camera)
			{
				method_8("SetFreezeFrameCamera", camera);
			}

			public Camera GetFreezeFrameCamera()
			{
				return method_14<Camera>("GetFreezeFrameCamera", Array.Empty<object>());
			}

			public void EnableFadeOut(bool enable)
			{
				method_8("EnableFadeOut", enable);
			}

			public bool IsFadeOutEnabled()
			{
				return method_11<bool>("IsFadeOutEnabled", Array.Empty<object>());
			}

			public void EnableFadeIn(bool enable)
			{
				method_8("EnableFadeIn", enable);
			}

			public bool IsFadeInEnabled()
			{
				return method_11<bool>("IsFadeInEnabled", Array.Empty<object>());
			}

			public void SetFadeColor(Color color)
			{
				method_8("SetFadeColor", color);
			}

			public Color GetFadeColor()
			{
				return method_11<Color>("GetFadeColor", Array.Empty<object>());
			}

			public List<Camera> GetCameras()
			{
				return method_14<Class271<Camera>>("GetCameras", Array.Empty<object>())?.method_25();
			}

			public void FixupCameras(Camera fxCamera)
			{
				method_8("FixupCameras", fxCamera);
			}

			public void AutoAddObjects()
			{
				method_8("AutoAddObjects");
			}

			public void PreserveObjects(Transform parent)
			{
				method_8("PreserveObjects", parent);
			}

			public void DestroyObjects()
			{
				method_8("DestroyObjects");
			}
		}

		[Attribute38("LoadingScreen.TransitionUnfriendlyData")]
		public class TransitionUnfriendlyData : MonoClass
		{
			public TransitionUnfriendlyData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public TransitionUnfriendlyData(IntPtr address)
				: this(address, "TransitionUnfriendlyData")
			{
			}

			public void Clear()
			{
				method_8("Clear");
			}

			public void Restore()
			{
				method_8("Restore");
			}
		}

		public float m_FadeOutSec => method_2<float>("m_FadeOutSec");

		public iTween.EaseType m_FadeOutEaseType => method_2<iTween.EaseType>("m_FadeOutEaseType");

		public float m_FadeInSec => method_2<float>("m_FadeInSec");

		public iTween.EaseType m_FadeInEaseType => method_2<iTween.EaseType>("m_FadeInEaseType");

		public static float MIDDLE_OF_NOWHERE_X => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "LoadingScreen", "MIDDLE_OF_NOWHERE_X");

		public Phase m_phase => method_2<Phase>("m_phase");

		public bool m_previousSceneActive => method_2<bool>("m_previousSceneActive");

		public TransitionParams m_prevTransitionParams => method_3<TransitionParams>("m_prevTransitionParams");

		public TransitionParams m_transitionParams => method_3<TransitionParams>("m_transitionParams");

		public TransitionUnfriendlyData m_transitionUnfriendlyData => method_3<TransitionUnfriendlyData>("m_transitionUnfriendlyData");

		public Camera m_fxCamera => method_3<Camera>("m_fxCamera");

		public float m_originalPosX => method_2<float>("m_originalPosX");

		public long m_assetLoadStartTimestamp => method_2<long>("m_assetLoadStartTimestamp");

		public long m_assetLoadEndTimestamp => method_2<long>("m_assetLoadEndTimestamp");

		public long m_assetLoadNextStartTimestamp => method_2<long>("m_assetLoadNextStartTimestamp");

		public LoadingScreen(IntPtr address, string className)
			: base(address, className)
		{
		}

		public LoadingScreen(IntPtr address)
			: this(address, "LoadingScreen")
		{
		}

		public static LoadingScreen Get()
		{
			return MonoClass.smethod_15<LoadingScreen>(TritonHs.MainAssemblyPath, "", "LoadingScreen", "Get", Array.Empty<object>());
		}

		public static bool DoesShowLoadingScreen(SceneMgr.Mode prevMode, SceneMgr.Mode nextMode)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "LoadingScreen", "DoesShowLoadingScreen", new object[2] { prevMode, nextMode });
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void Start()
		{
			method_8("Start");
		}

		public Camera GetFxCamera()
		{
			return method_14<Camera>("GetFxCamera", Array.Empty<object>());
		}

		public CameraFade GetCameraFade()
		{
			return method_14<CameraFade>("GetCameraFade", Array.Empty<object>());
		}

		public void RegisterSceneListeners()
		{
			method_8("RegisterSceneListeners");
		}

		public void UnregisterSceneListeners()
		{
			method_8("UnregisterSceneListeners");
		}

		public void WillReset()
		{
			method_8("WillReset");
		}

		public Phase GetPhase()
		{
			return method_11<Phase>("GetPhase", Array.Empty<object>());
		}

		public bool IsTransitioning()
		{
			return method_11<bool>("IsTransitioning", Array.Empty<object>());
		}

		public bool IsWaiting()
		{
			return method_11<bool>("IsWaiting", Array.Empty<object>());
		}

		public bool IsFadingOut()
		{
			return method_11<bool>("IsFadingOut", Array.Empty<object>());
		}

		public bool IsFadingIn()
		{
			return method_11<bool>("IsFadingIn", Array.Empty<object>());
		}

		public bool IsFading()
		{
			return method_11<bool>("IsFading", Array.Empty<object>());
		}

		public bool IsPreviousSceneActive()
		{
			return method_11<bool>("IsPreviousSceneActive", Array.Empty<object>());
		}

		public bool IsTransitionEnabled()
		{
			return method_11<bool>("IsTransitionEnabled", Array.Empty<object>());
		}

		public void EnableTransition(bool enable)
		{
			method_8("EnableTransition", enable);
		}

		public void AddTransitionObject(GameObject go)
		{
			method_9("AddTransitionObject", new Class276.Enum20[1] { Class276.Enum20.Class }, go);
		}

		public void AddTransitionObject(Component c)
		{
			method_9("AddTransitionObject", new Class276.Enum20[1] { Class276.Enum20.Class }, c);
		}

		public void AddTransitionBlocker()
		{
			method_9("AddTransitionBlocker", new Class276.Enum20[0]);
		}

		public void AddTransitionBlocker(int count)
		{
			method_9("AddTransitionBlocker", new Class276.Enum20[1] { Class276.Enum20.I4 }, count);
		}

		public Camera GetFreezeFrameCamera()
		{
			return method_14<Camera>("GetFreezeFrameCamera", Array.Empty<object>());
		}

		public void SetFreezeFrameCamera(Camera camera)
		{
			method_8("SetFreezeFrameCamera", camera);
		}

		public void EnableFadeOut(bool enable)
		{
			method_8("EnableFadeOut", enable);
		}

		public void EnableFadeIn(bool enable)
		{
			method_8("EnableFadeIn", enable);
		}

		public Color GetFadeColor()
		{
			return method_11<Color>("GetFadeColor", Array.Empty<object>());
		}

		public void SetFadeColor(Color color)
		{
			method_8("SetFadeColor", color);
		}

		public void NotifyTransitionBlockerComplete()
		{
			method_9("NotifyTransitionBlockerComplete", new Class276.Enum20[0]);
		}

		public void NotifyTransitionBlockerComplete(int count)
		{
			method_9("NotifyTransitionBlockerComplete", new Class276.Enum20[1] { Class276.Enum20.I4 }, count);
		}

		public void NotifyMainSceneObjectAwoke(GameObject mainObject)
		{
			method_8("NotifyMainSceneObjectAwoke", mainObject);
		}

		public long GetAssetLoadStartTimestamp()
		{
			return method_11<long>("GetAssetLoadStartTimestamp", Array.Empty<object>());
		}

		public void SetAssetLoadStartTimestamp(long timestamp)
		{
			method_8("SetAssetLoadStartTimestamp", timestamp);
		}

		public void OnFatalError(FatalErrorMessage message, object userData)
		{
			method_8("OnFatalError", message, userData);
		}

		public void OnScenePreUnload(SceneMgr.Mode prevMode, PegasusScene prevScene, object userData)
		{
			method_8("OnScenePreUnload", prevMode, prevScene, userData);
		}

		public void OnSceneUnloaded(SceneMgr.Mode prevMode, PegasusScene prevScene, object userData)
		{
			method_8("OnSceneUnloaded", prevMode, prevScene, userData);
		}

		public void OnSceneLoaded(SceneMgr.Mode mode, PegasusScene scene, object userData)
		{
			method_8("OnSceneLoaded", mode, scene, userData);
		}

		public bool TransitionIfPossible()
		{
			return method_11<bool>("TransitionIfPossible", Array.Empty<object>());
		}

		public void FirePreviousSceneDestroyedListeners()
		{
			method_8("FirePreviousSceneDestroyedListeners");
		}

		public void FireFinishedTransitionListeners(bool cutoff)
		{
			method_8("FireFinishedTransitionListeners", cutoff);
		}

		public void FadeOut()
		{
			method_8("FadeOut");
		}

		public void OnFadeOutComplete()
		{
			method_8("OnFadeOutComplete");
		}

		public void FadeIn()
		{
			method_8("FadeIn");
		}

		public void OnFadeInComplete()
		{
			method_8("OnFadeInComplete");
		}

		public void InitializeFxCamera()
		{
			method_8("InitializeFxCamera");
		}

		public void FinishFxCamera()
		{
			method_8("FinishFxCamera");
		}

		public FullScreenEffects GetFullScreenEffects(Camera camera)
		{
			return method_14<FullScreenEffects>("GetFullScreenEffects", new object[1] { camera });
		}

		public void ShowFreezeFrame(Camera camera)
		{
			method_8("ShowFreezeFrame", camera);
		}

		public void CutoffTransition()
		{
			method_8("CutoffTransition");
		}

		public void StopFading()
		{
			method_8("StopFading");
		}

		public void DoInterruptionCleanUp()
		{
			method_8("DoInterruptionCleanUp");
		}

		public void FinishPreviousScene()
		{
			method_8("FinishPreviousScene");
		}

		public void ClearPreviousSceneAssets()
		{
			method_8("ClearPreviousSceneAssets");
		}

		public void ClearAssets(long startTimestamp, long endTimestamp)
		{
			method_8("ClearAssets", startTimestamp, endTimestamp);
		}

		public void DisableTransitionUnfriendlyStuff(GameObject mainObject)
		{
			method_8("DisableTransitionUnfriendlyStuff", mainObject);
		}
	}
}
